Dominando Fixtures Avanzados de Pytest: Pruebas Parametrizadas e Integración de Mocks

Pytest es un framework de pruebas para Python potente y flexible. Su simplicidad y extensibilidad lo convierten en un favorito entre los desarrolladores de todo el mundo. Una de las características más atractivas de Pytest es su sistema de fixtures, que permite configuraciones de prueba elegantes y reutilizables. Esta publicación de blog profundiza en técnicas avanzadas de fixtures, centrándose específicamente en las pruebas parametrizadas y la integración de mocks. Exploraremos cómo estas técnicas pueden mejorar significativamente tu flujo de trabajo de pruebas, lo que lleva a un código más robusto y mantenible.

Entendiendo los Fixtures de Pytest

Antes de sumergirnos en temas avanzados, repasemos brevemente los conceptos básicos de los fixtures de Pytest. Un fixture es una función que se ejecuta antes de cada función de prueba a la que se aplica. Se utiliza para proporcionar una base fija para las pruebas, asegurando la consistencia y reduciendo el código repetitivo. Los fixtures pueden realizar tareas como:

• Configurar una conexión a la base de datos
• Crear archivos o directorios temporales
• Inicializar objetos con configuraciones específicas
• Autenticarse con una API

Los fixtures promueven la reutilización del código y hacen que tus pruebas sean más legibles y mantenibles. Se pueden definir en diferentes ámbitos (función, módulo, sesión) para controlar su ciclo de vida y consumo de recursos.

Ejemplo de Fixture Básico

Aquí hay un ejemplo simple de un fixture de Pytest que crea un directorio temporal:

            
import pytest
import tempfile
import os

@pytest.fixture
def temp_dir():
    with tempfile.TemporaryDirectory() as tmpdir:
        yield tmpdir

            

              
                Copy
              
            
          

Para usar este fixture en una prueba, simplemente inclúyelo como un argumento en tu función de prueba:

            
def test_create_file(temp_dir):
    filepath = os.path.join(temp_dir, "test_file.txt")
    with open(filepath, "w") as f:
        f.write("Hello, world!")
    assert os.path.exists(filepath)

            

              
                Copy
              
            
          

Pruebas Parametrizadas con Pytest

Las pruebas parametrizadas te permiten ejecutar la misma función de prueba varias veces con diferentes conjuntos de datos de entrada. Esto es particularmente útil para probar funciones con diversas entradas y salidas esperadas. Pytest proporciona el decorador @pytest.mark.parametrize para implementar pruebas parametrizadas.

Beneficios de las Pruebas Parametrizadas

• Reduce la Duplicación de Código: Evita escribir múltiples funciones de prueba casi idénticas.
• Mejora la Cobertura de Pruebas: Prueba fácilmente una gama más amplia de valores de entrada.
• Mejora la Legibilidad de las Pruebas: Define claramente los valores de entrada y las salidas esperadas para cada caso de prueba.

Ejemplo de Parametrización Básica

Digamos que tienes una función que suma dos números:

            
def add(x, y):
    return x + y

            

              
                Copy
              
            
          

Puedes usar pruebas parametrizadas para probar esta función con diferentes valores de entrada:

            
import pytest

@pytest.mark.parametrize("x, y, expected", [
    (1, 2, 3),
    (5, 5, 10),
    (-1, 1, 0),
    (0, 0, 0),
])
def test_add(x, y, expected):
    assert add(x, y) == expected

            

              
                Copy
              
            
          

En este ejemplo, el decorador @pytest.mark.parametrize define cuatro casos de prueba, cada uno con diferentes valores para x, y y el resultado esperado. Pytest ejecutará la función test_add cuatro veces, una por cada conjunto de parámetros.

Técnicas de Parametrización Avanzadas

Pytest ofrece varias técnicas avanzadas para la parametrización, que incluyen:

• Uso de Fixtures con Parametrización: Combina fixtures con parametrización para proporcionar diferentes configuraciones para cada caso de prueba.
• IDs para Casos de Prueba: Asigna IDs personalizados a los casos de prueba para mejorar los informes y la depuración.
• Parametrización Indirecta: Parametriza los argumentos pasados a los fixtures, permitiendo la creación dinámica de fixtures.

Uso de Fixtures con Parametrización

Esto te permite configurar dinámicamente los fixtures en función de los parámetros pasados a la prueba. Imagina que estás probando una función que interactúa con una base de datos. Es posible que desees utilizar diferentes configuraciones de base de datos (por ejemplo, diferentes cadenas de conexión) para diferentes casos de prueba.

            
import pytest

@pytest.fixture
def db_config(request):
    if request.param == "prod":
        return {"host": "prod.example.com", "port": 5432}
    elif request.param == "test":
        return {"host": "test.example.com", "port": 5433}
    else:
        raise ValueError("Invalid database environment")


@pytest.fixture
def db_connection(db_config):
    # Simulate establishing a database connection
    print(f"Connecting to database at {db_config['host']}:{db_config['port']}")
    return f"Connection to {db_config['host']}"


@pytest.mark.parametrize("db_config", ["prod", "test"], indirect=True)
def test_database_interaction(db_connection):
    # Your test logic here, using the db_connection fixture
    print(f"Using connection: {db_connection}")
    assert "Connection" in db_connection

            

              
                Copy
              
            
          

En este ejemplo, el fixture db_config está parametrizado. El argumento indirect=True le dice a Pytest que pase los parámetros ("prod" y "test") a la función del fixture db_config. El fixture db_config luego devuelve diferentes configuraciones de base de datos según el valor del parámetro. El fixture db_connection utiliza el fixture db_config para establecer una conexión a la base de datos. Finalmente, la función test_database_interaction utiliza el fixture db_connection para interactuar con la base de datos.

IDs para Casos de Prueba

Los IDs personalizados proporcionan nombres más descriptivos para tus casos de prueba en el informe de pruebas, lo que facilita la identificación y depuración de fallos.

            
import pytest

@pytest.mark.parametrize(
    "input_string, expected_output",
    [
        ("hello", "HELLO"),
        ("world", "WORLD"),
        ("", ""),
    ],
    ids=["lowercase_hello", "lowercase_world", "empty_string"],
)
def test_uppercase(input_string, expected_output):
    assert input_string.upper() == expected_output

            

              
                Copy
              
            
          

Sin IDs, Pytest generaría nombres genéricos como test_uppercase[0], test_uppercase[1], etc. Con IDs, el informe de pruebas mostrará nombres más significativos como test_uppercase[lowercase_hello].

Parametrización Indirecta

La parametrización indirecta te permite parametrizar la entrada a un fixture, en lugar de la función de prueba directamente. Esto es útil cuando deseas crear diferentes instancias de fixtures basadas en el valor del parámetro.

            
import pytest

@pytest.fixture
def input_data(request):
    if request.param == "valid":
        return {"name": "John Doe", "email": "john.doe@example.com"}
    elif request.param == "invalid":
        return {"name": "", "email": "invalid-email"}
    else:
        raise ValueError("Invalid input data type")


def validate_data(data):
    if not data["name"]:
        return False, "Name cannot be empty"
    if "@" not in data["email"]:
        return False, "Invalid email address"
    return True, "Valid data"

@pytest.mark.parametrize("input_data", ["valid", "invalid"], indirect=True)
def test_validate_data(input_data):
    is_valid, message = validate_data(input_data)
    if input_data == {"name": "John Doe", "email": "john.doe@example.com"}:
        assert is_valid is True
        assert message == "Valid data"
    else:
        assert is_valid is False
        assert message in ["Name cannot be empty", "Invalid email address"]

            

              
                Copy
              
            
          

En este ejemplo, el fixture input_data se parametriza con los valores "valid" e "invalid". El argumento indirect=True le dice a Pytest que pase estos valores a la función del fixture input_data. El fixture input_data luego devuelve diferentes diccionarios de datos según el valor del parámetro. La función test_validate_data luego utiliza el fixture input_data para probar la función validate_data con diferentes datos de entrada.

Mocking con Pytest

El mocking es una técnica utilizada para reemplazar dependencias reales con sustitutos controlados (mocks) durante las pruebas. Esto te permite aislar el código que se está probando y evitar depender de sistemas externos, como bases de datos, APIs o sistemas de archivos.

Beneficios del Mocking

• Aislar el Código: Prueba el código de forma aislada, sin depender de dependencias externas.
• Controlar el Comportamiento: Define el comportamiento de las dependencias, como valores de retorno y excepciones.
• Acelerar las Pruebas: Evita sistemas externos lentos o poco fiables.
• Probar Casos Límite: Simula condiciones de error y casos límite que son difíciles de reproducir en un entorno real.

Uso de la biblioteca unittest.mock

Python proporciona la biblioteca unittest.mock para crear mocks. Pytest se integra perfectamente con unittest.mock, lo que facilita la simulación de dependencias en tus pruebas.

Ejemplo de Mocking Básico

Digamos que tienes una función que recupera datos de una API externa:

            
import requests

def get_data_from_api(url):
    response = requests.get(url)
    response.raise_for_status()  # Raise an exception for bad status codes
    return response.json()

            

              
                Copy
              
            
          

Para probar esta función sin realizar realmente una solicitud a la API, puedes hacer un mock de la función requests.get:

            
import pytest
import requests
from unittest.mock import patch

@patch("requests.get")
def test_get_data_from_api(mock_get):
    # Configure the mock to return a specific response
    mock_get.return_value.json.return_value = {"data": "test data"}
    mock_get.return_value.status_code = 200

    # Call the function being tested
    data = get_data_from_api("https://example.com/api")

    # Assert that the mock was called with the correct URL
    mock_get.assert_called_once_with("https://example.com/api")

    # Assert that the function returned the expected data
    assert data == {"data": "test data"}

            

              
                Copy
              
            
          

En este ejemplo, el decorador @patch("requests.get") reemplaza la función requests.get con un objeto mock. El argumento mock_get es el objeto mock. Luego podemos configurar el objeto mock para que devuelva una respuesta específica y afirmar que fue llamado con la URL correcta.

Mocking con Fixtures

También puedes usar fixtures para crear y gestionar mocks. Esto puede ser útil para compartir mocks entre múltiples pruebas o para crear configuraciones de mock más complejas.

            
import pytest
import requests
from unittest.mock import Mock

@pytest.fixture
def mock_api_get():
    mock = Mock()
    mock.return_value.json.return_value = {"data": "test data"}
    mock.return_value.status_code = 200
    return mock


@pytest.fixture
def patched_get(mock_api_get, monkeypatch):
    monkeypatch.setattr(requests, "get", mock_api_get)
    return mock_api_get


def test_get_data_from_api(patched_get):
    # Call the function being tested
    data = get_data_from_api("https://example.com/api")

    # Assert that the mock was called with the correct URL
    patched_get.assert_called_once_with("https://example.com/api")

    # Assert that the function returned the expected data
    assert data == {"data": "test data"}

            

              
                Copy
              
            
          

Aquí, mock_api_get crea un mock y lo devuelve. patched_get luego usa monkeypatch, un fixture de pytest, para reemplazar el requests.get real con el mock. Esto permite que otras pruebas usen el mismo endpoint de API simulado.

Técnicas de Mocking Avanzadas

Pytest y unittest.mock ofrecen varias técnicas de mocking avanzadas, que incluyen:

• Efectos Secundarios (Side Effects): Define un comportamiento personalizado para los mocks basado en los argumentos de entrada.
• Mocking de Propiedades: Simula propiedades de objetos.
• Gestores de Contexto: Usa mocks dentro de gestores de contexto para reemplazos temporales.

Efectos Secundarios

Los efectos secundarios te permiten definir un comportamiento personalizado para tus mocks basado en los argumentos de entrada que reciben. Esto es útil para simular diferentes escenarios o condiciones de error.

            
import pytest
from unittest.mock import Mock

def test_side_effect():
    mock = Mock()
    mock.side_effect = [1, 2, 3]

    assert mock() == 1
    assert mock() == 2
    assert mock() == 3
    with pytest.raises(StopIteration):
        mock()

            

              
                Copy
              
            
          

Este mock devuelve 1, 2 y 3 en llamadas sucesivas, luego lanza una excepción `StopIteration` cuando la lista se agota.

Mocking de Propiedades

El mocking de propiedades te permite simular el comportamiento de las propiedades en los objetos. Esto es útil para probar código que depende de las propiedades de los objetos en lugar de los métodos.

            
import pytest
from unittest.mock import patch

class MyClass:
    @property
    def my_property(self):
        return "original value"


def test_property_mocking():
    obj = MyClass()
    with patch.object(obj, "my_property", new_callable=pytest.PropertyMock) as mock_property:
        mock_property.return_value = "mocked value"
        assert obj.my_property == "mocked value"

            

              
                Copy
              
            
          

Este ejemplo simula la propiedad my_property del objeto MyClass, lo que te permite controlar su valor de retorno durante la prueba.

Gestores de Contexto

Usar mocks dentro de gestores de contexto te permite reemplazar temporalmente dependencias para un bloque de código específico. Esto es útil para probar código que interactúa con sistemas o recursos externos que solo deben ser simulados por un tiempo limitado.

            
import pytest
from unittest.mock import patch


def test_context_manager_mocking():
    with patch("os.path.exists") as mock_exists:
        mock_exists.return_value = True
        assert os.path.exists("dummy_path") is True
    # The mock is automatically reverted after the 'with' block
    # Ensure the original function is restored, although we can't really assert
    # the real `os.path.exists` function's behavior without a real path.
    # The important thing is that the patch is gone after the context.
    print("Mock has been removed")

            

              
                Copy
              
            
          

Combinando Parametrización y Mocking

Estas dos potentes técnicas se pueden combinar para crear pruebas aún más sofisticadas y efectivas. Puedes usar la parametrización para probar diferentes escenarios con diferentes configuraciones de mock.

            
import pytest
import requests
from unittest.mock import patch


def get_user_data(user_id):
    url = f"https://api.example.com/users/{user_id}"
    response = requests.get(url)
    response.raise_for_status()
    return response.json()


@pytest.mark.parametrize(
    "user_id, expected_data",
    [
        (1, {"id": 1, "name": "John Doe"}),
        (2, {"id": 2, "name": "Jane Smith"}),
    ],
)
@patch("requests.get")
def test_get_user_data(mock_get, user_id, expected_data):
    mock_get.return_value.json.return_value = expected_data
    mock_get.return_value.status_code = 200

    data = get_user_data(user_id)

    assert data == expected_data
    mock_get.assert_called_once_with(f"https://api.example.com/users/{user_id}")

            

              
                Copy
              
            
          

En este ejemplo, la función test_get_user_data está parametrizada con diferentes valores de user_id y expected_data. El decorador @patch simula la función requests.get. Pytest ejecutará la función de prueba dos veces, una por cada conjunto de parámetros, con el mock configurado para devolver el expected_data correspondiente.

Mejores Prácticas para Usar Fixtures Avanzados

• Mantén los Fixtures Enfocados: Cada fixture debe tener un propósito claro y específico.
• Usa Ámbitos Apropiados: Elige el ámbito de fixture apropiado (función, módulo, sesión) para optimizar el uso de recursos.
• Documenta los Fixtures: Documenta claramente el propósito y el uso de cada fixture.
• Evita el Exceso de Mocking: Solo simula las dependencias que son necesarias para aislar el código que se está probando.
• Escribe Aserciones Claras: Asegúrate de que tus aserciones sean claras y específicas, verificando el comportamiento esperado del código que se está probando.
• Considera el Desarrollo Guiado por Pruebas (TDD): Escribe tus pruebas antes de escribir el código, utilizando fixtures y mocks para guiar el proceso de desarrollo.

Conclusión

Las técnicas avanzadas de fixtures de Pytest, incluidas las pruebas parametrizadas y la integración de mocks, proporcionan herramientas potentes para escribir pruebas robustas, eficientes y mantenibles. Al dominar estas técnicas, puedes mejorar significativamente la calidad de tu código Python y optimizar tu flujo de trabajo de pruebas. Recuerda centrarte en crear fixtures claros y específicos, usar los ámbitos apropiados y escribir aserciones completas. Con la práctica, podrás aprovechar todo el potencial del sistema de fixtures de Pytest para crear una estrategia de pruebas integral y efectiva.